Please address the comments from this code review:
## Overall Comments
- The `create_integrator_copy` stub in `ParallelTimeoutIntegrator` will throw at runtime—add a proper integrator‐copy mechanism or factory to ensure parallel/batch methods work without error.
- `ParallelTimeoutIntegrator` is very large and mixes strategy selection with execution details—consider extracting each execution strategy (sequential, parallel, async, hybrid) into its own class or helper to improve readability and maintainability.

## Individual Comments

### Comment 1
<location> `include/core/parallel_timeout_integrator.hpp:491` </location>
<code_context>
+        return std::min(config_.max_parallel_tasks, hardware_caps_.cpu_cores);
+    }
+
+    std::unique_ptr<Integrator> create_integrator_copy() {
+        // This is a placeholder - actual implementation would depend on integrator type
+        // Could use a factory pattern or require integrators to be copyable
+        throw std::runtime_error("Integrator copying not implemented - need factory pattern");
+    }
+
</code_context>

<issue_to_address>
The create_integrator_copy method is unimplemented and throws at runtime.

This stub will cause runtime failures in parallel or batch operations unless users implement their own copy logic. To prevent such errors, require integrators to be copyable or provide a factory/copy mechanism in the interface.
</issue_to_address>

### Comment 2
<location> `include/core/parallel_timeout_integrator.hpp:497` </location>
<code_context>
+        throw std::runtime_error("Integrator copying not implemented - need factory pattern");
+    }
+
+    std::unique_ptr<ParallelTimeoutIntegrator> create_thread_local_integrator() {
+        // Create a new integrator for thread-local use
+        // This is needed for true parallelization
+        auto local_config = config_;
+        local_config.strategy = ExecutionStrategy::SEQUENTIAL;  // Avoid nested parallelization
+        
+        return std::make_unique<ParallelTimeoutIntegrator>(
+            create_integrator_copy(), local_config);
+    }
+};
</code_context>

<issue_to_address>
Thread-local integrator creation depends on create_integrator_copy, which is not implemented.

This dependency causes runtime exceptions when using batch or Monte Carlo integration, making the parallel API appear functional when it is not. Please document this limitation clearly or refactor to prevent misuse.
</issue_to_address>

### Comment 3
<location> `include/core/parallel_timeout_integrator.hpp:258` </location>
<code_context>
+        using result_type = std::invoke_result_t<Processor, S>;
+        std::vector<result_type> results(num_simulations);
+
+        std::for_each(std::execution::par_unseq,
+            std::views::iota(0UL, num_simulations).begin(),
+            std::views::iota(0UL, num_simulations).end(),
+            [&](size_t i) {
+                auto local_integrator = this->create_copy();
+                auto state = generator(i);
</code_context>

<issue_to_address>
Use of std::execution::par_unseq assumes hardware and compiler support.

Check hardware_caps_.supports_std_execution before using par_unseq, or provide a fallback to par or sequential execution if unsupported.
</issue_to_address>

### Comment 4
<location> `include/core/parallel_timeout_integrator.hpp:399` </location>
<code_context>
+        }
+        
+        // Estimate problem characteristics
+        double integration_steps = (end_time - 0) / dt;  // Assuming start time is 0
+        double problem_size = state.size() * integration_steps;
+        
+        // Select strategy based on problem characteristics and hardware
</code_context>

<issue_to_address>
Assumes start time is always zero when estimating integration steps.

This may result in incorrect step estimates if integration starts at a nonzero time. Use the actual start time from the integrator or state to improve accuracy.

Suggested implementation:

```
    ExecutionStrategy select_execution_strategy(
        const state_type& state, 
        time_type dt, 
        time_type start_time,
        time_type end_time
    ) {
        if (config_.strategy != ExecutionStrategy::AUTO) {
            return config_.strategy;
        }

        // Estimate problem characteristics
        double integration_steps = (end_time - start_time) / dt;
        double problem_size = state.size() * integration_steps;

        // Select strategy based on problem characteristics and hardware

```

You will need to update all call sites of `select_execution_strategy` to pass the correct `start_time` value as an argument. This may require retrieving the start time from the integrator or state, depending on your codebase.
</issue_to_address>

### Comment 5
<location> `include/core/timeout_integrator.hpp:50` </location>
<code_context>
+    std::string error_message;
+    
+    bool is_success() const { return completed && error_message.empty(); }
+    bool is_timeout() const { return !completed && error_message.find("timeout") != std::string::npos; }
+};
+
</code_context>

<issue_to_address>
Timeout detection relies on error message string matching.

Checking for the substring "timeout" in error messages is unreliable and may cause incorrect detection if messages change or are localized. Use a status field or error code for timeout detection instead.

Suggested implementation:

```
enum class IntegrationStatus {
    Success,
    Timeout,
    Failure
};

struct IntegrationResult {
    bool completed{false};                          // Whether integration completed successfully
    std::chrono::milliseconds elapsed_time{0};     // Total elapsed time
    double final_time{0.0};                        // Final integration time reached
    std::string error_message;                     // Error message if failed
    IntegrationStatus status{IntegrationStatus::Success}; // Explicit status

    // Success indicators
    bool is_success() const { return status == IntegrationStatus::Success; }
    bool is_timeout() const { return status == IntegrationStatus::Timeout; }
};

```

You will need to update all code that creates or modifies `IntegrationResult` to set the `status` field appropriately (e.g., set `status = IntegrationStatus::Timeout` when a timeout occurs, and `status = IntegrationStatus::Failure` for other errors).
</issue_to_address>

### Comment 6
<location> `include/core/timeout_integrator.hpp:155` </location>
<code_context>
+     * @param timeout Optional timeout override
+     * @return true if completed successfully, false if timed out
+     */
+    bool integrate_with_timeout_simple(state_type& state, time_type dt, time_type end_time,
+                                      std::chrono::milliseconds timeout = std::chrono::milliseconds{0}) {
+        auto old_config = config_;
+        if (timeout.count() > 0) {
+            config_.timeout_duration = timeout;
+        }
+        config_.throw_on_timeout = false;
+        
+        auto result = integrate_with_timeout(state, dt, end_time);
+        config_ = old_config; // Restore original config
+        
+        return result.completed;
+    }
+
</code_context>

<issue_to_address>
integrate_with_timeout_simple ignores error type and only returns completion.

Currently, this method only indicates if the integration completed, not whether it succeeded or failed due to an error (other than timeout). Consider returning more detailed status information or checking is_success() to avoid masking non-timeout failures.

Suggested implementation:

```
     * @param timeout Optional timeout override
     * @return IntegrationResult containing completion and success status
     */
    IntegrationResult integrate_with_timeout_simple(state_type& state, time_type dt, time_type end_time,
                                      std::chrono::milliseconds timeout = std::chrono::milliseconds{0}) {
        auto old_config = config_;
        if (timeout.count() > 0) {
            config_.timeout_duration = timeout;
        }
        config_.throw_on_timeout = false;

        auto result = integrate_with_timeout(state, dt, end_time);
        config_ = old_config; // Restore original config

        return result;
    }

```

- Ensure that `IntegrationResult` (or the actual result type returned by `integrate_with_timeout`) is accessible in this context and documents both completion and success/error status.
- Update any code that calls `integrate_with_timeout_simple` to handle the new return type.
- If you want to expose only a subset of the result (e.g., a struct with `completed` and `success`), you can define and return such a struct instead.
</issue_to_address>

### Comment 7
<location> `include/core/composable_integration.hpp:358` </location>
<code_context>
+        }
+    }
+
+    void buffer_output(const S& state, T time) {
+        if (output_buffer_.size() >= config_.buffer_size) {
+            output_buffer_.erase(output_buffer_.begin());
+        }
+        output_buffer_.emplace_back(state, time);
+    }
+
</code_context>

<issue_to_address>
Output buffer uses erase(begin) for buffer overflow, which is O(n).

Using erase(begin) on std::vector is O(n) and may degrade performance with large buffers. Consider a circular buffer or std::deque for more efficient removal of the oldest element.

Suggested implementation:

```
#include <deque>

```

```
        if (output_buffer_.size() >= config_.buffer_size) {
            output_buffer_.erase(output_buffer_.begin());
        }
        output_buffer_.emplace_back(state, time);

```

You must also change the declaration of `output_buffer_` from `std::vector` to `std::deque` in the class definition (not shown in the provided code). For example:
`std::vector<...> output_buffer_;`
should become
`std::deque<...> output_buffer_;`
</issue_to_address>

### Comment 8
<location> `test/unit/test_advanced_integrators.cpp:209` </location>
<code_context>
         integrator.set_time(0.0);
-        EXPECT_NO_THROW(integrator.integrate(y, dt, t_end));
+        
+        bool completed = diffeq::integrate_with_timeout(integrator, y, dt, t_end, TIMEOUT);
+        ASSERT_TRUE(completed) << "RK4 integration timed out after " << TIMEOUT.count() << " seconds";
+        
         // Just check solution is bounded (Lorenz attractor is bounded)
</code_context>

<issue_to_address>
Consider adding tests for timeout expiration and error handling.

Add a test where the integration exceeds the timeout to ensure the timeout mechanism triggers and the test fails as expected.
</issue_to_address>

### Comment 9
<location> `test/integration/test_modernized_interface.cpp:325` </location>
<code_context>
-            auto future = async_integrator->integrate_async(initial_state, 0.01, 1.0);
+            auto future = async_integrator->integrate_async(initial_state, 0.01, 0.5);  // Reduced from 1.0 to 0.5 seconds
+            
+            // Wait for completion with timeout
+            const std::chrono::seconds TIMEOUT{3};
+            if (future.wait_for(TIMEOUT) == std::future_status::timeout) {
+                std::cout << "     Async integration timed out after " << TIMEOUT.count() << " seconds" << std::endl;
+                return false;
</code_context>

<issue_to_address>
Missing test for async timeout failure path.

Please add a test that triggers a timeout to verify correct handling of async integration timeouts.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
            auto future = async_integrator->integrate_async(initial_state, 0.01, 0.5);  // Reduced from 1.0 to 0.5 seconds

            // Wait for completion with timeout
            const std::chrono::seconds TIMEOUT{3};
            if (future.wait_for(TIMEOUT) == std::future_status::timeout) {
                std::cout << "     Async integration timed out after " << TIMEOUT.count() << " seconds" << std::endl;
                return false;
            }

            future.wait();
            std::cout << "     Async integration completed: ✓" << std::endl;
=======
            auto future = async_integrator->integrate_async(initial_state, 0.01, 0.5);  // Reduced from 1.0 to 0.5 seconds

            // Wait for completion with timeout
            const std::chrono::seconds TIMEOUT{3};
            if (future.wait_for(TIMEOUT) == std::future_status::timeout) {
                std::cout << "     Async integration timed out after " << TIMEOUT.count() << " seconds" << std::endl;
                return false;
            }

            future.wait();
            std::cout << "     Async integration completed: ✓" << std::endl;

            // --- Test: Async integration timeout failure path ---
            {
                std::vector<double> timeout_state = {1.0, 0.0};
                // Set integration duration much longer than timeout to force timeout
                auto timeout_future = async_integrator->integrate_async(timeout_state, 0.01, 10.0);
                const std::chrono::seconds SHORT_TIMEOUT{1};
                if (timeout_future.wait_for(SHORT_TIMEOUT) == std::future_status::timeout) {
                    std::cout << "     [TEST] Async integration timeout failure path triggered as expected after "
                              << SHORT_TIMEOUT.count() << " seconds" << std::endl;
                } else {
                    std::cerr << "     [TEST] ERROR: Async integration did not timeout as expected" << std::endl;
                    return false;
                }
            }
            // --- End test ---
>>>>>>> REPLACE

</suggested_fix>

### Comment 10
<location> `test/integration/test_modernized_interface.cpp:371` </location>
<code_context>
+        auto end_time = std::chrono::high_resolution_clock::now();
+        
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
+        if (duration.count() > 2000) {  // 2-second timeout
+            std::cout << "     Signal-aware integration took too long: " << duration.count() << "ms" << std::endl;
+            return false;
+        }

</code_context>

<issue_to_address>
Consider asserting on the return value to ensure test failure on timeout.

Using an assertion on the duration will cause the test to fail if the timeout is exceeded, making the failure explicit and the test's intent clearer.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
        if (duration.count() > 2000) {  // 2-second timeout
            std::cout << "     Signal-aware integration took too long: " << duration.count() << "ms" << std::endl;
            return false;
        }
=======
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
        ASSERT_LE(duration.count(), 2000) << "Signal-aware integration took too long: " << duration.count() << "ms";
>>>>>>> REPLACE

</suggested_fix>

### Comment 11
<location> `test/unit/test_dop853.cpp:231` </location>
<code_context>

     try {
-        integrator.integrate(y, 0.01, 1.0);
+        bool completed = diffeq::integrate_with_timeout(integrator, y, 0.01, 0.5, TIMEOUT);  // Reduced from 1.0 to 0.5 seconds
+        ASSERT_TRUE(completed) << "DOP853 performance test timed out after " << TIMEOUT.count() << " seconds";

         auto end_time = std::chrono::high_resolution_clock::now();
</code_context>

<issue_to_address>
No test for timeout expiration with DOP853 integrator.

Please add a test that ensures the DOP853 integrator triggers and handles a timeout as expected, such as by using a stiff system or a very short timeout value.
</issue_to_address>